﻿using Base.Core20;
using Base.Core20.Enums;
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.Threading;
using Winservice.demo.Common;
using Winservice.demo.Queue;
using Winservice.demo.Models.Entities;


namespace Winservice.demo.Business
{
    /// <summary>
    /// 线程状态
    /// </summary>
    public class ThreadWithState
    {
        /// <summary>
        /// 线程开始
        /// </summary>
        public async void ThreadProcessing()
        {
            AppConfig appConfig;

            Console.WriteLine("Ready");
            //Thread.CurrentThread.Join(1000 * 20 * 1);  //在20秒内进行附加进程
            Thread.CurrentThread.Join(1000 * 3 * 1);  //在 5 秒内进行附加进程
            Console.WriteLine("Go");

            //for (int i = 0; i <= 10; i++)
            //{
            //    Console.WriteLine(i.ToString());
            //}
            //return;

            //启动队列
            //实例化队列任务管理对象
            QueueManager queueManager = new QueueManager();
            QueueDoing queueDoing = new QueueDoing(queueManager);
            //先启动读取线程，不过现在没内容，要等一会加入后，就能读到了 
            QueueDoing.Start(queueManager);

            bool isRun = false; //默认不执行
            while (true)
            {
                appConfig = Utils.CreateInstance().GetAppConfig();

                //大小写的区别:
                //HH:mm 14:50 //24小时制
                //hh:mm 02:50
                //string hour = DateTime.Now.ToString("hh");
                //string hour = DateTime.Now.ToString("HH:mm");
                string hour = DateTime.Now.ToString("HH"); //获得当前的时间

                isRun = Utils.CreateInstance().TimeOut(appConfig, hour) ? true : false;

                if (isRun == true)
                {
                    // 晚上 凌晨时，将数据移动至 历史库 或者 删除  (主要条件为 FLOW_INCIDENT 表中 的 FLOW_INCIDENT_STATUS in (103,104))
                    /*
                     FLOW_STEPUSER_HISTORY         新增 FLOW_STEPUSER 表 根据 FLOW_INCIDENT_ID 即 ID
                     FLOW_TASK_HISTORY             新增 FLOW_TASK     表 根据 FLOW_INCIDENT_ID 即 ID
                     FLOW_INCIDENT_HISTORY         新增 FLOW_INCIDENT 表 根据 FLOW_INCIDENT_ID 即 ID
                     ...
                     //第一种情况的
                     QUEUE_TASK                    删除 根据 STATUS=103 并且 THIRD_ID<>''
                     ...
                     //第二种情况的
                     QUEUE_TASK                    删除 根据 STATUS=103 并且 THIRD_ID = FLOW_TASK 中的 FLOW_INCIDENT_ID 的 103 或者 104
                     ...
                     FLOW_QUEUE                    删除 根据 FLOW_INCIDENT_ID
                     FLOW_VARIABLES                删除 根据 FLOW_INCIDENT_ID
                     FLOW_COUNTERSIGN_FINISHED     删除 根据 FLOW_INCIDENT_ID
                     FLOW_COUNTERSIGN              删除 根据 FLOW_INCIDENT_ID
                     FLOW_STEPUSER                 删除 根据 FLOW_INCIDENT_ID
                     FLOW_TASK                     删除 根据 FLOW_INCIDENT_ID
                     FLOW_INCIDENT                 删除 根据 FLOW_INCIDENT_ID 即 ID
                     */
                    // ======================= 业务 0 开始 ======================= //
                    var result_DeleteIncident = await new TaskApproval_Business().GetDeleteIncidentIDAsync(appConfig.DAYS_BY_DELETE);
                    if (result_DeleteIncident != null)
                    {
                        foreach (FLOW_INCIDENT_DELETE d in result_DeleteIncident)
                        {
                            await new TaskApproval_Business().DeleteInfoByIncidentID(d.FLOW_INCIDENT_ID);
                        }
                    }
                    // ======================= 业务 0 结束 ======================= //
                    isRun = false;  //重要：当操作完一次后，就不需要再次操作了并休眠一个多小时（保证在一个小时内，不操作第二次）
                    Thread.CurrentThread.Join(1000 * 60 * 62);   //休眠 62 分钟  //必须要超过 一个 小时
                }

                // 把已经完成的流程 数据 进行 修改
                var result_FinishedIncident = await new TaskApproval_Business().GetFinishedIncidentByA5Async();
                if (result_FinishedIncident != null)
                {
                    List<CustomProcess> customProcessList = await Utils.CreateInstance().GetCustomProcessAsync();
                    foreach (FLOW_INCIDENT_FINISHED d in result_FinishedIncident)
                    {
                        if (d.STATUS == 4)
                        {
                            // 流程中止
                            await new TaskApproval_Business().SetIncidentIsAbort(d.PROCESS_NAME, d.INCIDENT);
                        }
                        else
                        {
                            // 流程正常结束
                            await new TaskApproval_Business().SetIncidentIsEnd(d.PROCESS_NAME, d.INCIDENT);
                        }

                        // 定制的业务 Start
                        if (customProcessList != null)
                        {
                            foreach (var custom in customProcessList)
                            {
                                if (d.PROCESS_NAME.Trim().Equals(custom.ProcessName.Trim()))
                                {
                                    //就去执行SQL
                                    await new TaskApproval_Business().SetCustomProcess(d.PROCESS_NAME, d.INCIDENT, custom.Sql);
                                }
                            }
                        }
                        // 定制的业务 End
                    }
                }

                //Thread.Sleep(1000 * appConfig.INTERVAL_TIME); //休眠1分钟
                Thread.Sleep(1000 * 10); //休眠 10 秒


                //先查询下队列中的任务是否都已经完成，如果完成，则查询数据库；如果未完成，则休息一下，等到队列中的数据完成后再操作。
                if (queueManager.IsAvailable)
                {
                    Thread.Sleep(5000);//休眠5秒钟
                    continue;
                }

                // ======================= 业务 开始 ======================= //
                TaskApproval_Business business = new TaskApproval_Business();
                var tasks = await business.GetTaskApproval();
                if (tasks != null)
                {
                    foreach (QueueTask queueTask in tasks)
                    {
                        int iResult = await business.UpdateTaskApprovalStatusAsync(queueTask.FLOW_TASK_ID, FLOW_TASK_STATUS_Enum.QUEUE_IN, "");

                        if (iResult > 0)
                        {
                            // 进入队列
                            queueManager.AddQueue(queueTask);
                            continue;
                        }

                        // 写出日志，帮助 后面 维护的时候，可以手动修改之
                        Logger2.CreateInstance().Write("任务入队列的维护"
                              , MethodBase.GetCurrentMethod()
                              , null
                              , string.Format("任务入队列的异常({0})\r\nFLOW_TASK_ID:{1}\r\nPROCESS_NAME:{2}\r\nINCIDENT:{3}\r\nFLOW_INCIDENT_ID:{4}\r\nCURRENT_STEP_KEY:{5}({6})", DateTime.Now, queueTask.FLOW_TASK_ID, queueTask.PROCESS_NAME, queueTask.INCIDENT, queueTask.FLOW_INCIDENT_ID, queueTask.CURRENT_STEP_KEY, FLOW_TASK_STATUS_Enum.QUEUE_IN.GetHashCode()));

                        await business.UpdateStatusIsExceptionAsync(queueTask.FLOW_INCIDENT_ID, queueTask.FLOW_TASK_ID, "任务入队列的维护");
                    }
                }
                // ======================= 业务 结束 ======================= //

                //Thread.CurrentThread.Join(1000 * 60 * 1);  //停止设定时间，精确度比Sleep高
                Thread.Sleep(1000 * appConfig.INTERVAL_TIME); //休眠1分钟
            }



        }

    }
}
